package ltmgr

import (
	"context"
	"fmt"
	"reflect"
	"sync"
	"time"

	"gitee.com/MM-Q/colorlib"
)

// LtMgrInterface 定义了 LtMgr 的接口。
// 该接口包含了 LtMgr 结构体的所有公共方法，用于管理并发任务。
type LtMgrInterface interface {
	// AddTasks 将任务添加到任务队列中，并为每个任务创建一个结果通道。
	// 参数:
	//   task: 要执行的任务函数。
	//   taskID: 任务的唯一标识符。
	//   repeats: 任务重复执行的次数。
	//   params: 任务函数的参数。
	AddTasks(task interface{}, taskID int, repeats int, params ...interface{})

	// Run 执行所有任务。
	// 该方法会遍历任务队列中的每个任务，为每个任务启动一个协程，并使用信号量控制并发数量。
	// 所有任务执行完成后，该方法会打印任务执行结果。
	Run()

	// RunWithContext 执行所有任务，并在上下文取消时停止执行。
	// 该方法会遍历任务队列中的每个任务，为每个任务启动一个协程，并使用信号量控制并发数量。
	// 如果任务执行过程中上下文被取消，任务将被标记为取消状态。
	// 所有任务执行完成后，该方法会打印任务执行结果。
	RunWithContext()

	// GetTaskStatusByID 根据任务ID获取任务的执行状态。
	// 参数:
	//   taskID: 任务的唯一标识符。
	// 返回值:
	//   *TaskStatus: 任务的执行状态。
	//   error: 如果任务状态不存在，返回相应的错误信息。
	GetTaskStatusByID(taskID int) (*TaskStatus, error)

	// GetTaskResult 通过任务ID获取任务的执行结果/任务函数的返回值。
	// 参数:
	//	taskID: 任务的唯一标识符。
	// 返回值:
	//	map[int]interface{}: 任务的执行结果，以整数为键，任意类型为值的映射。
	//	error: 如果任务结果通道不存在或获取结果超时，返回相应的错误信息。
	GetTaskResult(taskID int) (map[int]interface{}, error)

	// GetTaskStatuses 返回所有任务的执行状态。
	// 返回值:
	//   map[int]*TaskStatus: 任务执行状态map ( 任务ID 到任务状态的映射 )。
	GetTaskStatuses() map[int]*TaskStatus

	// Stop 停止所有任务的执行。只能在支持上下文方式运行的情况下使用。
	// 该方法会调用取消函数取消所有任务，并等待所有任务完成。
	Stop()

	// Wait 等待所有任务完成。 一般情况下，不需要手动调用该方法，因为 Run 和 RunWithContext 方法会自动等待所有任务完成。
	// 该方法会等待所有任务执行完成，并打印任务执行结果。
	Wait()

	// ClearAll 清理所有资源。
	// 该方法用于重置任务管理器中的所有状态和资源，确保可以安全地重新开始任务处理。
	ClearAll()
}

// LtMgr 提供管理并发任务的能力
type LtMgr struct {
	Concurrency      int                                  // 允许的最大并发数
	sem              chan struct{}                        // 用于控制并发数量的信号量
	wg               sync.WaitGroup                       // 用于等待所有任务完成
	Statuses         map[int]*TaskStatus                  // 任务执行状态map ( 任务ID 到任务状态的映射 )
	TasksFunc        []func(...interface{}) []interface{} // 任务函数队列
	TasksParams      [][]interface{}                      // 任务参数队列
	TasksIDs         []int                                // 任务 ID 队列
	mu               sync.Mutex                           // 用于保护 Statuses 切片的锁
	color            *colorlib.ColorLib                   // 用于输出提示信息的颜色库
	EnablePrint      bool                                 // 是否启用打印信息 ( 默认启用 )
	ctx              context.Context                      // 上下文，用于取消任务
	cancel           context.CancelFunc                   // 取消函数
	resultCh         map[int]chan []interface{}           // 任务 ID 到结果通道的映射
	rmu              sync.Mutex                           // 用于保护 resultCh 的锁
	GetResultTimeout int                                  // 设置获取任务结果的超时时间 ( 单位: 秒, 默认: 1 秒 )
}

// 记录任务执行状态
type TaskStatus struct {
	ID        int    // 存储任务的唯一标识符
	StartTime string // 存储任务的开始时间
	EndTime   string // 存储任务的结束时间
	Error     error  // 存储任务执行过程中捕获的错误，支持 nil 表示无错误
}

// NewLtMgr 创建一个新的 LtMgr 实例。
// 参数:
//
//	concurrency: 允许的最大并发数。
//
// 返回值:
//
//	*LtMgr: 新创建的 LtMgr 实例。
func NewLtMgr(concurrency int) (*LtMgr, error) {
	// 创建一个固定容量的通道作为信号量，用于控制并发数量。
	sem := make(chan struct{}, concurrency)

	// 创建一个颜色库实例，用于输出提示信息。
	color := colorlib.NewColorLib()

	// 创建一个上下文和取消函数，用于取消任务。
	ctx, cancel := context.WithCancel(context.Background())

	// 返回一个新的 LtMgr 实例。
	return &LtMgr{
		Concurrency:      concurrency,                            // 设置并发数量。
		sem:              sem,                                    // 设置信号量。
		wg:               sync.WaitGroup{},                       // 初始化等待组。
		mu:               sync.Mutex{},                           // 初始化互斥锁。
		rmu:              sync.Mutex{},                           // 初始化结果通道锁。
		Statuses:         make(map[int]*TaskStatus),              // 初始化任务状态映射。
		TasksFunc:        []func(...interface{}) []interface{}{}, // 初始化任务函数队列。
		TasksParams:      [][]interface{}{},                      // 初始化任务参数队列。
		TasksIDs:         []int{},                                // 初始化任务 ID 队列。
		color:            color,                                  // 初始化提示信息颜色库。
		EnablePrint:      true,                                   // 默认启用打印信息。
		ctx:              ctx,                                    // 设置上下文。
		cancel:           cancel,                                 // 设置取消函数。
		resultCh:         make(map[int]chan []interface{}),       // 初始化结果通道映射。
		GetResultTimeout: 1,                                      // 默认获取结果超时时间为 1 秒。
	}, nil
}

// AddTasks 将任务添加到任务队列中，并为每个任务创建一个结果通道。
// 参数:
//
//	task: 要执行的任务函数。
//	taskID: 任务的唯一标识符。
//	repeats: 任务重复执行的次数。
//	params: 任务函数的参数。
func (tm *LtMgr) AddTasks(task interface{}, taskID int, repeats int, params ...interface{}) error {
	// 加锁，确保在多线程环境下对共享资源的安全访问。
	tm.mu.Lock()

	// 使用 defer 关键字确保在函数结束时解锁，即使发生 panic 也能保证解锁。
	defer tm.mu.Unlock()

	// 使用反射获取任务函数的反射值。
	fnValue := reflect.ValueOf(task)
	// 获取任务函数的类型信息。
	fnType := fnValue.Type()

	// 检查传入的参数数量是否与任务函数所需的参数数量匹配。
	if len(params) != fnType.NumIn() {
		// 如果参数数量不匹配，返回一个错误，指出任务ID、所需参数数量和实际提供的参数数量。
		return fmt.Errorf("任务 %d 参数数量不匹配, 需要 %d 个参数, 但提供了 %d 个", taskID, fnType.NumIn(), len(params))
	}

	// 遍历任务函数的每个参数。
	for j := 0; j < fnType.NumIn(); j++ {
		// 获取当前参数的类型。
		paramType := fnType.In(j)
		// 获取实际传入参数的类型。
		actualType := reflect.TypeOf(params[j])
		// 检查实际传入参数的类型是否与任务函数所需的参数类型匹配。
		if actualType != paramType && !actualType.AssignableTo(paramType) {
			// 如果类型不匹配，返回一个错误，指出任务ID、参数索引、所需类型和实际提供的类型。
			return fmt.Errorf("任务 %d 参数类型不匹配, 参数 %d 需要 %v, 但提供了 %v", taskID, j, paramType, actualType)
		}
	}

	// 根据指定的重复次数，将任务添加到任务队列中。
	for i := 0; i < repeats; i++ {
		// 包装任务函数，使其能够处理任意类型的参数和返回值。
		wrappedTask := WrapTaskFunction(task)

		// 将包装后的任务函数添加到任务函数队列中。
		tm.TasksFunc = append(tm.TasksFunc, wrappedTask)
		// 将任务参数添加到任务参数队列中。
		tm.TasksParams = append(tm.TasksParams, params)
		// 将任务ID添加到任务ID队列中。
		tm.TasksIDs = append(tm.TasksIDs, taskID)

		// 加锁，确保在多线程环境下对共享资源的安全访问。
		tm.rmu.Lock()

		// 获取参数数量，如果参数数量为0，则设置为2。
		paramCount := len(params)
		if paramCount == 0 {
			paramCount = 2
		}

		// 为任务创建一个结果通道，并将其添加到结果通道映射中。
		tm.resultCh[taskID] = make(chan []interface{}, paramCount)

		// 解锁，允许其他线程访问共享资源。
		tm.rmu.Unlock()
	}

	// 打印任务添加成功的信息。
	if tm.EnablePrint {
		tm.PrintSuccessf("任务 %d 已添加到队列", taskID)
	}

	// 如果所有操作都成功，返回 nil 表示没有错误。
	return nil
}

// Run 执行所有任务。
// 该方法会遍历任务队列中的每个任务，为每个任务启动一个协程，并使用信号量控制并发数量。
// 所有任务执行完成后，该方法会打印任务执行结果。
func (tm *LtMgr) Run() {
	// 遍历任务队列中的每个任务。
	for taskIndex := 0; taskIndex < len(tm.TasksFunc); taskIndex++ {
		// 获取任务函数、参数和任务 ID。
		task := tm.TasksFunc[taskIndex]
		params := tm.TasksParams[taskIndex]
		taskID := tm.TasksIDs[taskIndex]

		// 增加等待组计数。
		tm.wg.Add(1)

		// 启动任务协程。
		go func(task func(...interface{}) []interface{}, params []interface{}, taskID int) {
			// 任务执行完成后，调用 wg.Done() 表示任务已完成。
			defer tm.wg.Done()

			// 获取信号量槽位。
			tm.sem <- struct{}{}

			// 任务执行完成后，释放信号量槽位。
			defer func() {
				<-tm.sem
			}()

			// 记录任务开始时间。
			startTime := time.Now().Format("2006-01-02 15:04:05")

			// 打印任务开始执行信息。
			if tm.EnablePrint {
				tm.PrintSuccessf("任务 %d 开始执行, 参数: %v", taskID, params)
			}

			var err error
			//var result []interface{} // 存储任务函数的返回值。

			// 执行任务函数，并获取返回值。
			result := task(params...)
			if tm.EnablePrint {
				tm.PrintSuccessf("任务 %d 执行完成, 返回值: %v", taskID, result)
			}

			// 记录任务状态。
			tm.handleTaskResult(taskID, startTime, result, &err)

		}(task, params, taskID)
	}

	// 等待所有任务完成。
	tm.wg.Wait()

	// 打印所有任务执行完成信息。
	if tm.EnablePrint {
		tm.PrintSuccess("所有任务已执行完成")
	}
}

// GetTaskStatusByID 根据任务ID获取任务的执行状态。
// 参数:
//
//	taskID: 任务的唯一标识符。
//
// 返回值:
//
//	*TaskStatus: 任务的执行状态。
//	error: 如果任务状态不存在，返回相应的错误信息。
func (tm *LtMgr) GetTaskStatusByID(taskID int) (*TaskStatus, error) {
	// 加锁，确保并发安全。
	tm.mu.Lock()
	// 函数结束时解锁。
	defer tm.mu.Unlock()

	// 检查 Statuses 是否为空。
	if tm.Statuses == nil {
		return nil, fmt.Errorf("任务状态未初始化")
	}

	// 任务状态映射。
	if status, ok := tm.Statuses[taskID]; ok {
		// 如果找到任务状态，返回该状态。
		return status, nil
	}

	// 如果未找到任务状态，返回错误信息。
	if tm.EnablePrint {
		tm.PrintErrorf("任务 ID %d 的状态未找到", taskID)
	}

	// 如果未找到任务状态，返回错误信息。
	return nil, fmt.Errorf("未找到任务 ID 为 %d 的任务状态", taskID)
}

// GetTaskResult 通过任务ID获取任务的执行结果/任务函数的返回值。
// 参数:
//
//	taskID: 任务的唯一标识符。
//
// 返回值:
//
//	map[int]interface{}: 任务的执行结果，以整数为键，任意类型为值的映射。
//	error: 如果任务结果通道不存在或获取结果超时，返回相应的错误信息。
func (tm *LtMgr) GetTaskResult(taskID int) (map[int]interface{}, error) {
	// 加锁，确保并发安全。
	tm.rmu.Lock()
	// 函数结束时解锁。
	defer tm.rmu.Unlock()

	// 从结果通道映射中获取任务ID对应的结果通道。
	ch, ok := tm.resultCh[taskID]
	// 如果结果通道不存在。
	if !ok {
		// 如果启用了打印信息。
		if tm.EnablePrint {
			// 打印错误信息。
			tm.PrintErrorf("任务 %d 的结果通道不存在", taskID)
		}
		// 返回错误信息。
		return nil, fmt.Errorf("任务 %d 的结果通道不存在", taskID)
	}

	// 如果结果通道为空。
	if ch == nil {
		return nil, fmt.Errorf("任务 %d 的结果通道为空", taskID)
	}

	// 等待结果。
	var result []interface{}
	select {
	// 从结果通道中获取结果。
	case res := <-ch:
		// 如果结果为空，返回错误信息。
		if res == nil {
			return nil, fmt.Errorf("任务 %d 的结果通道已关闭", taskID)
		}
		result = res // 将结果赋值给 result 变量。
	// 如果等待超时，返回错误信息。 设置超时时间为 GetResultTimeout 秒。
	case <-time.After(time.Duration(tm.GetResultTimeout) * time.Second):
		return nil, fmt.Errorf("任务 %d 的结果超时", taskID)
	}

	// 将结果切片转换为 map
	resultMap := make(map[int]interface{})
	for i, value := range result {
		resultMap[i] = value
	}

	return resultMap, nil
}

// GetTaskStatuses 返回所有任务的执行状态。
// 该方法会返回一个映射，其中键是任务ID，值是任务的执行状态。
// 返回值:
//
//	map[int]*TaskStatus: 任务执行状态map ( 任务ID 到任务状态的映射 )。
func (tm *LtMgr) GetTaskStatuses() map[int]*TaskStatus {
	// 加锁，确保并发安全。
	tm.mu.Lock()
	// 函数结束时解锁。
	defer tm.mu.Unlock()

	// 如果任务状态映射为空，则返回一个空映射。
	if tm.Statuses == nil {
		return make(map[int]*TaskStatus)
	}

	// 创建一个深拷贝，防止外部直接修改内部状态。
	result := make(map[int]*TaskStatus)
	for k, v := range tm.Statuses {
		// 如果 TaskStatus 包含指针或复杂结构，需要进一步深拷贝。
		result[k] = v // 假设 TaskStatus 是基本类型或不可变结构。
	}

	// 返回任务状态映射。
	return result
}

// Wait 等待所有任务完成。一般情况下，不需要手动调用该方法，因为 Run 和 RunWithContext 方法会自动等待所有任务完成。
func (tm *LtMgr) Wait() {
	// 等待所有任务完成
	tm.wg.Wait()
}

// RunWithContext 执行所有任务，并在上下文取消时停止执行。
// 该方法会遍历任务队列中的每个任务，为每个任务启动一个协程，并使用信号量控制并发数量。
// 如果任务执行过程中上下文被取消，任务将被标记为取消状态。
// 所有任务执行完成后，该方法会打印任务执行结果。
func (tm *LtMgr) RunWithContext() {
	// 确保在函数退出时调用取消函数
	defer tm.cancel()

	// 遍历任务队列中的每个任务
	for taskIndex := 0; taskIndex < len(tm.TasksFunc); taskIndex++ {
		// 获取任务函数、参数和任务 ID
		task := tm.TasksFunc[taskIndex]
		params := tm.TasksParams[taskIndex]
		taskID := tm.TasksIDs[taskIndex]

		// 增加等待组计数
		tm.wg.Add(1)

		// 启动任务协程
		go func(task func(...interface{}) []interface{}, params []interface{}, taskID int) {
			defer tm.wg.Done()

			// 获取信号量槽位
			select {
			case tm.sem <- struct{}{}:
				// 信号量槽位获取成功
			case <-tm.ctx.Done():
				// 如果获取信号量失败（任务被取消），记录任务状态
				tm.updateTaskStatus(taskID, "", time.Now().Format(time.RFC3339), tm.ctx.Err())
				return
			}

			defer func() {
				// 释放信号量槽位
				<-tm.sem
			}()

			startTime := time.Now().Format(time.RFC3339)
			if tm.EnablePrint {
				tm.PrintInfof("任务 %d 开始执行", taskID)
			}

			var result []interface{}
			var err error

			// 启动任务协程
			done := make(chan struct{})
			defer close(done)

			// 启动任务协程
			go func() {
				// 执行任务函数
				if tm.EnablePrint {
					tm.PrintDebugf("任务协程开始执行任务函数 %d", taskID)
				}

				// 检查上下文是否被取消
				select {
				case <-tm.ctx.Done():
					if tm.EnablePrint {
						tm.PrintWarningf("任务 %d 被取消", taskID)
					}
					return // 提前退出协程
				default:
					result = task(params...)
				}

				// 检查上下文是否被取消
				select {
				case <-tm.ctx.Done():
					if tm.EnablePrint {
						tm.PrintWarningf("任务 %d 被取消", taskID)
					}
				default:
					if tm.EnablePrint {
						tm.PrintDebug("任务协程即将发送到 done 通道")
					}
					done <- struct{}{} // 只有当上下文未被取消时才发送消息
					if tm.EnablePrint {
						tm.PrintDebug("任务协程已发送到 done 通道")
					}
				}
			}()

			if tm.EnablePrint {
				tm.PrintDebug("主 goroutine 准备监听 done 通道")
			}

			// 等待任务完成或上下文被取消
			select {
			case <-tm.ctx.Done():
				// 如果上下文被取消，记录任务状态
				err = tm.ctx.Err() // 获取取消原因
				if tm.EnablePrint {
					tm.PrintWarningf("任务被取消，取消原因：%v", err)
				}
				tm.updateTaskStatus(taskID, startTime, time.Now().Format(time.RFC3339), err)
				if tm.EnablePrint {
					tm.PrintWarningf("任务 %d 被取消", taskID)
				}
				return // 任务被取消，返回
			case <-done:
				// 任务正常完成
				// 稍后返回时完成任务状态的更新
				if tm.EnablePrint {
					tm.PrintDebug("done 通道被触发")
				}
				tm.handleTaskResult(taskID, startTime, result, &err)
				if tm.EnablePrint {
					tm.PrintInfo("任务, 任务状态更新完成")
				}
			}
			if tm.EnablePrint {
				tm.PrintWarning("任务正常完成")
			}
		}(task, params, taskID)
	}

	// 等待所有任务完成
	tm.wg.Wait()

	// 打印任务执行结果
	if tm.EnablePrint {
		tm.PrintSuccess("所有任务执行完成")
	}
}

// updateTaskStatus 更新任务的执行状态。
// 参数:
//
//	taskID: 任务的唯一标识符。
//	startTime: 任务的开始时间。
//	endTime: 任务的结束时间。
//	err: 任务执行过程中捕获的错误，支持 nil 表示无错误。
func (tm *LtMgr) updateTaskStatus(taskID int, startTime, endTime string, err error) {
	// 加锁，确保并发安全。
	tm.mu.Lock()
	// 函数结束时解锁。
	defer tm.mu.Unlock()

	// 更新任务状态。
	tm.Statuses[taskID] = &TaskStatus{
		ID:        taskID,
		StartTime: startTime,
		EndTime:   endTime,
		Error:     err,
	}

	// 如果启用了打印信息。
	if tm.EnablePrint {
		// 打印任务状态更新信息。
		tm.PrintInfof("任务 %d 状态已更新到任务状态map", taskID)
	}
}

// handleTaskResult 处理任务函数的返回值和错误信息，并更新任务状态.
// 捕获任务执行时的 panic。
// 处理任务函数返回的错误或结果。
// 更新任务状态（调用 updateTaskStatus）。
func (tm *LtMgr) handleTaskResult(taskID int, startTime string, result []interface{}, err *error) {
	defer func() {
		if r := recover(); r != nil {
			*err = fmt.Errorf("任务执行发生 panic: %v", r)
			if tm.EnablePrint {
				tm.PrintErrorf("任务 %d 发生 panic: %v", taskID, r)
			}
		}

		// 默认值是 nil，即无返回值
		var resultVal []interface{}
		if result != nil {
			resultVal = result
		} else {
			resultVal = []interface{}{nil}
		}

		// 检查任务函数是否直接返回了 error
		if *err == nil {
			if len(resultVal) > 0 {
				if e, ok := resultVal[0].(error); ok {
					*err = e
				}
			}
		}

		// 更新任务状态
		endTime := time.Now().Format(time.RFC3339)

		// 更新任务状态
		tm.updateTaskStatus(taskID, startTime, endTime, *err)

		// 打印任务执行结果
		if tm.EnablePrint {
			if *err != nil {
				if tm.EnablePrint {
					tm.PrintErrorf("任务 %d 执行失败: %v", taskID, *err)
				}
			} else {
				if tm.EnablePrint {
					tm.PrintSuccessf("任务 %d 执行完成", taskID)
				}
			}
		}
	}()

	// 将结果发送到对应的通道
	tm.rmu.Lock()
	select {
	case tm.resultCh[taskID] <- result:
		// 结果已发送
		if tm.EnablePrint {
			tm.PrintSuccessf("任务 %d 已将执行结果发送到通道", taskID)
		}
	default:
		// 通道已满，无法发送结果
		err := fmt.Errorf("无法发送 任务%d 结果到通道，通道已满", taskID)
		if tm.EnablePrint {
			tm.PrintErrorf("任务 %d 发送结果到通道失败: %v", taskID, err)
		}
	}
	tm.rmu.Unlock()
}

// Stop 停止所有任务的执行。只能在支持上下文方式运行的情况下使用。
// 该方法会调用取消函数取消所有任务，并等待所有任务完成。
func (tm *LtMgr) Stop() {
	// 调用 LtMgr 结构体中的 cancel 方法，用于取消正在进行的操作或 goroutine
	tm.cancel()

	// 等待所有的 goroutine 完成，防止在它们还在运行时退出该方法
	tm.wg.Wait()
}

// WrapTaskFunction 包装一个函数，使其能够处理任意类型的参数和返回值。
// 参数:
//
//	fn: 要包装的函数。
//
// 返回值:
//
//	func(...interface{}) []interface{}: 包装后的函数，接受任意类型的参数并返回任意类型的结果。
func WrapTaskFunction(fn interface{}) func(...interface{}) []interface{} {
	// 获取函数的反射值。
	fnValue := reflect.ValueOf(fn)
	// 获取函数的反射类型。
	fnType := fnValue.Type()

	// 获取函数的返回值类型。
	resultTypes := make([]reflect.Type, fnType.NumOut())
	for i := 0; i < fnType.NumOut(); i++ {
		resultTypes[i] = fnType.Out(i)
	}

	// 创建返回值变量。
	resultVars := make([]reflect.Value, len(resultTypes))
	for i, t := range resultTypes {
		resultVars[i] = reflect.New(t).Elem()
	}

	return func(params ...interface{}) []interface{} {
		// 准备参数。
		var in []reflect.Value
		for i := 0; i < fnType.NumIn(); i++ {
			if i >= len(params) {
				return []interface{}{fmt.Errorf("参数数量不足，函数需要 %d 个参数，但只提供了 %d 个", fnType.NumIn(), len(params))}
			}
			param := params[i]
			paramType := fnType.In(i)
			argValue := reflect.ValueOf(param)
			if !argValue.Type().AssignableTo(paramType) {
				return []interface{}{fmt.Errorf("参数类型不匹配，需要 %v, 但得到 %v", paramType, argValue.Type())}
			}
			in = append(in, argValue)
		}

		// 调用函数。
		out := fnValue.Call(in)

		// 将返回值存储到结果变量中。
		for i, v := range out {
			resultVars[i].Set(v)
		}

		// 将结果变量转换为 []interface{} 返回。
		results := make([]interface{}, len(resultVars))
		for i, v := range resultVars {
			results[i] = v.Interface()
		}

		return results
	}
}

func (tm *LtMgr) PrintErrorf(format string, args ...interface{}) {
	tm.color.PrintErrorf(format, args...)
}

func (tm *LtMgr) PrintSuccessf(format string, args ...interface{}) {
	tm.color.PrintSuccessf(format, args...)
}

func (tm *LtMgr) PrintInfof(format string, args ...interface{}) {
	tm.color.PrintInfof(format, args...)
}

func (tm *LtMgr) PrintWarningf(format string, args ...interface{}) {
	tm.color.PrintWarningf(format, args...)
}

func (tm *LtMgr) PrintError(args ...interface{}) {
	tm.color.PrintError(args...)
}

func (tm *LtMgr) PrintSuccess(args ...interface{}) {
	tm.color.PrintSuccess(args...)
}

func (tm *LtMgr) PrintInfo(args ...interface{}) {
	tm.color.PrintInfo(args...)
}

func (tm *LtMgr) PrintWarning(args ...interface{}) {
	tm.color.PrintWarning(args...)
}

func (tm *LtMgr) PrintDebug(args ...interface{}) {
	tm.color.PrintDebug(args...)
}

func (tm *LtMgr) PrintDebugf(format string, args ...interface{}) {
	tm.color.PrintDebugf(format, args...)
}

// ClearAll 清理所有资源。
// 该方法用于重置任务管理器中的所有状态和资源，确保可以安全地重新开始任务处理。
func (tm *LtMgr) ClearAll() {
	// 加锁，确保并发安全
	tm.mu.Lock()
	defer tm.mu.Unlock()

	// 清理所有任务状态
	tm.Statuses = make(map[int]*TaskStatus)

	if tm.EnablePrint {
		tm.PrintInfo("已清理所有任务状态")
	}

	// 清理所有任务函数
	tm.TasksFunc = nil

	if tm.EnablePrint {
		tm.PrintInfo("已清理所有任务函数")
	}

	// 清理所有任务参数
	tm.TasksParams = nil

	if tm.EnablePrint {
		tm.PrintInfo("已清理所有任务参数")
	}

	// 清理所有任务ID
	tm.TasksIDs = nil

	if tm.EnablePrint {
		tm.PrintInfo("已清理所有任务ID")
	}

	// 加锁，确保并发安全
	tm.rmu.Lock()
	defer tm.rmu.Unlock()

	// 清理所有结果通道
	tm.resultCh = make(map[int]chan []interface{})

	if tm.EnablePrint {
		tm.PrintInfo("已清理所有结果通道")
	}

	// 清理信号量
	tm.sem = make(chan struct{}, tm.Concurrency)

	if tm.EnablePrint {
		tm.PrintInfo("已清理并重置信号量")
	}
}
